home *** CD-ROM | disk | FTP | other *** search
/ Aminet 24 / Aminet 24 (1998)(GTI - Schatztruhe)[!][Apr 1998].iso / Aminet / dev / c / AmiVoGL_MDEV.lha / drivers / apollo.c < prev    next >
C/C++ Source or Header  |  1994-04-15  |  12KB  |  589 lines
  1. /*
  2.  *    Apollo driver for vogl.
  3.  */
  4.  
  5. #include "/sys/ins/base.ins.c"
  6. #include "/sys/ins/gpr.ins.c"
  7. #include "/sys/ins/pad.ins.c"
  8. #include "/sys/ins/kbd.ins.c"
  9. #include <stdio.h>
  10. #include "vogl.h"
  11.  
  12. #define FONTBASE "/sys/dm/fonts/"
  13.  
  14. #define MAXCOLORS        256
  15. #define MIN(x,y)        ((x) < (y) ? (x) : (y))
  16. #define COLOR_ENTRY(r, g, b)    (gpr_$pixel_value_t) ((r << 16) | (g << 8) | b)
  17.  
  18. static ios_$id_t        stream_id;
  19. static gpr_$pixel_value_t      color_value[MAXCOLORS];
  20. static gpr_$pixel_value_t      old_color_value[MAXCOLORS];
  21.  
  22. static gpr_$offset_t            init_bitmap_size;   
  23. static gpr_$bitmap_desc_t       current_bitmap, front_bitmap, back_bitmap;       
  24. static gpr_$attribute_desc_t       attribs;
  25. static gpr_$window_t           source;
  26. static gpr_$position_t           dest_pos;
  27.  
  28. static gpr_$display_mode_t      mode = gpr_$direct;
  29. static gpr_$plane_t             hi_plane_id = 0;    
  30. static boolean                  delete_display;    
  31. static status_$t                status;
  32. static gpr_$keyset_t            keys, mouse_keys;
  33.  
  34. static pad_$window_list_t     window_info;
  35. static short             n_windows;
  36. static gpr_$disp_char_t        disp;
  37. static short            disp_len;
  38.  
  39. static int             first_time, back_used;
  40. static int             current_color;
  41. static short             font_id;
  42.  
  43. /*
  44.  * Do nothing
  45.  *
  46.  */
  47. int noop(void)
  48. {
  49.     return(-1);
  50. }
  51.  
  52. /*
  53.  * APOLLO_init
  54.  *
  55.  *    initialises window to occupy current window
  56.  */
  57. int APOLLO_init(void)
  58. {
  59.     pad_$window_desc_t     window;
  60.     int     size, prefx, prefy, prefxs, prefys, x, y, w, h;
  61.     short     i;
  62.  
  63.     pad_$set_scale(stream_$stdout,
  64.                1,
  65.                1,
  66.                status);
  67.  
  68.     pad_$inq_windows(stream_$stdout,
  69.              window_info,
  70.                   10,
  71.                n_windows,
  72.                  status);
  73.  
  74.     w = window_info[0].width;
  75.     h = window_info[0].height;
  76.     x = window_info[0].left;
  77.     y = window_info[0].top;
  78.  
  79.     getprefposandsize(&prefx, &prefy, &prefxs, &prefys);
  80.  
  81.     if (prefx > -1) {
  82.         x = prefx;
  83.         y = prefy;
  84.     }
  85.  
  86.     if (prefxs > -1) {
  87.         w = prefxs;
  88.         h = prefys;
  89.     }
  90.  
  91.     size = MIN(w, h);
  92.     vdevice.sizeX = vdevice.sizeY = size - 1;
  93.     vdevice.sizeSx = w - 1;
  94.     vdevice.sizeSy = h - 1;
  95.  
  96.         init_bitmap_size.x_size = w;
  97.         init_bitmap_size.y_size = h;
  98.  
  99.     source.window_base.x_coord = source.window_base.y_coord = 0;
  100.     source.window_size.x_size = init_bitmap_size.x_size;
  101.     source.window_size.y_size = init_bitmap_size.y_size;
  102.     dest_pos.x_coord = dest_pos.y_coord = 0;
  103.  
  104.     /*
  105.      * Inquire about the actual display ....
  106.      */
  107.  
  108.     gpr_$inq_disp_characteristics(mode,
  109.                       stream_$stdout,
  110.                       (short)60,
  111.                       disp,
  112.                       disp_len,
  113.                       status);
  114.  
  115.     vdevice.depth = disp.n_planes;
  116.     hi_plane_id = disp.n_planes - 1;
  117.  
  118.     if (prefx == -1 && prefxs == -1) {
  119.         stream_id = stream_$stdout;
  120.     } else {
  121.         window.top = y;
  122.         window.left = x;
  123.         window.width = w;
  124.         window.height = h;
  125.  
  126.         pad_$create_window("", 0,
  127.                 pad_$transcript, 
  128.                 1, 
  129.                 window,
  130.                 stream_id,
  131.                 status
  132.         );
  133.  
  134.         pad_$set_auto_close(stream_id, 1, true, status);
  135.     }
  136.  
  137.         gpr_$init(mode,
  138.                   stream_id,
  139.                   init_bitmap_size,
  140.                   hi_plane_id,
  141.                   front_bitmap,
  142.                   status);
  143.  
  144.     current_bitmap = front_bitmap;
  145.  
  146.     gpr_$set_auto_refresh(true, status);
  147.   
  148.     gpr_$set_cursor_active(false,status);
  149.  
  150.     /*  Set up all the character stuff  */
  151.  
  152.     first_time = 1;
  153.  
  154.     /*  create a key set for the event interupts  */
  155.  
  156.     lib_$init_set(keys, (short)256);
  157.     lib_$init_set(mouse_keys, (short)6);
  158.  
  159.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M1D);
  160.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M2D);
  161.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M3D);
  162.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M1U);
  163.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M2U);
  164.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M3U);
  165.  
  166.     for (i = 0; i < 128; i++) 
  167.         lib_$add_to_set(keys, (short)256, (short)i);
  168.  
  169.     gpr_$enable_input(gpr_$keystroke, keys, status);
  170.     gpr_$enable_input(gpr_$buttons, keys, status);
  171.     gpr_$enable_input(gpr_$locator, keys, status);
  172.  
  173.     /*  set default color (colour)   */
  174.  
  175.     if (disp.n_planes > 1) {
  176.         gpr_$inq_color_map(0L, (short)MAXCOLORS, old_color_value, status);
  177.         gpr_$inq_color_map(0L, (short)MAXCOLORS, color_value, status);
  178.  
  179.         color_value[0] = COLOR_ENTRY(0,0,0);         /* color--black   */
  180.         color_value[1] = COLOR_ENTRY(255,0,0);       /* color--red     */
  181.         color_value[2] = COLOR_ENTRY(0,255,0);       /* color--green   */
  182.         color_value[3] = COLOR_ENTRY(255,255,0);     /* color--yellow  */
  183.         color_value[4] = COLOR_ENTRY(0,0,255);       /* color--blue    */
  184.         color_value[5] = COLOR_ENTRY(255,0,255);     /* color--magenta */
  185.         color_value[6] = COLOR_ENTRY(0,255,255);     /* color--cyan    */
  186.         color_value[7] = COLOR_ENTRY(255,255,255);   /* color--white   */
  187.  
  188.         /* modify color table */
  189.         gpr_$acquire_display(status);
  190.         gpr_$set_color_map((long)0,
  191.                     (short)MAXCOLORS,
  192.                     color_value,
  193.                     status);
  194.         gpr_$release_display(status);
  195.     }
  196.  
  197.     back_used = 0;
  198.  
  199.     return(1);
  200. }
  201.  
  202.  
  203. /*
  204.  * APOLLO_draw
  205.  *
  206.  *    Draw a lines from the current graphics position to (x, y).
  207.  */
  208. int APOLLO_draw(
  209.   int x,
  210.   int y)
  211. {
  212.     gpr_$acquire_display(status);
  213.     gpr_$move((short)vdevice.cpVx, (short)(vdevice.sizeSy - vdevice.cpVy), status);
  214.     gpr_$line((short)x, (short)(vdevice.sizeSy - y), status);
  215.     gpr_$release_display(status);
  216.     vdevice.cpVx = x;
  217.     vdevice.cpVy = y;
  218. }
  219.  
  220. /*
  221.  * APOLLO_getkey
  222.  *
  223.  *    grab a character from the keyboard
  224.  */
  225. int APOLLO_getkey(void)
  226. {
  227.     gpr_$event_t     et;
  228.     char         ed;
  229.     gpr_$position_t  pos;
  230.  
  231.  
  232.     et = gpr_$no_event;
  233.     while (et != gpr_$keystroke)
  234.         (void)gpr_$event_wait(et, ed, pos, status);
  235.  
  236.     /*
  237.      * What for this stupid gpr event system map the return key
  238.      * to a SYN character
  239.      */
  240.  
  241.     if ((ed & 0x7f) == 0x16)
  242.         ed = 13;
  243.  
  244.     return(ed);
  245. }
  246.  
  247. /*
  248.  * APOLLO_checkkey
  249.  *
  250.  *    checks if there is key waiting in the keyboard
  251.  */
  252. int APOLLO_checkkey(void)
  253. {
  254.     gpr_$event_t     et;
  255.     char             ed;
  256.     gpr_$position_t  pos;
  257.  
  258.     et = gpr_$no_event;
  259.  
  260.     (void)gpr_$cond_event_wait(et, ed, pos, status);
  261.  
  262.     return((et == gpr_$keystroke ? 1 : 0));
  263. }
  264.  
  265. /*
  266.  * APOLLO_locator
  267.  *
  268.  *      return the window location of the cursor, plus which mouse button,
  269.  * if any, is been pressed.
  270.  *
  271.  *    LOCATOR - needs to return straight away.
  272.  */
  273. int APOLLO_locator(
  274.   int *wx,
  275.   int *wy)
  276. {
  277.     gpr_$event_t     et;
  278.     char             ed;
  279.     gpr_$position_t  pos;
  280.     gpr_$position_t  origin;
  281.  
  282.     gpr_$bitmap_desc_t    curs_pat;
  283.     gpr_$raster_op_array_t    curs_raster_op;
  284.     boolean            active;
  285.     
  286.  
  287.  
  288.     (void)gpr_$cond_event_wait(et, ed, pos, status);
  289.  
  290.     gpr_$inq_cursor(curs_pat, curs_raster_op, active, pos, origin, status);
  291.  
  292.     *wx = (int)pos.x_coord;
  293.     *wy = (int)vdevice.sizeSy - (int)pos.y_coord;
  294.  
  295.     if (ed < 'a')            /* absorb button up */
  296.         return(0);
  297.  
  298.     return(1 << ((int)ed - 'a'));
  299. }
  300.  
  301. /*
  302.  * APOLLO_clear
  303.  *
  304.  *    clear the window to the current color.
  305.  */
  306. int APOLLO_clear(void)
  307. {
  308.         int     x[4], y[4];
  309.  
  310.         if (vdevice.maxVx != vdevice.sizeSx
  311.            || vdevice.maxVy != vdevice.sizeSy
  312.            || vdevice.minVx != 0
  313.            || vdevice.minVy != 0) {
  314.         x[0] = x[3] = vdevice.minVx;
  315.         y[0] = y[1] = vdevice.maxVy;
  316.         y[2] = y[3] = vdevice.minVy;
  317.         x[1] = x[2] = vdevice.maxVx;
  318.  
  319.                 APOLLO_fill(4, x, y);
  320.         } else {
  321.         gpr_$acquire_display(status);
  322.         gpr_$clear((long)current_color, status);
  323.         gpr_$release_display(status);
  324.         }
  325.  
  326. }
  327.  
  328. /*
  329.  * APOLLO_exit
  330.  *
  331.  *    reset the window back to normal mode (sigh)
  332.  */
  333. int APOLLO_exit(void)
  334. {
  335.     if (disp.n_planes > 1) {
  336.         gpr_$acquire_display(status);
  337.         gpr_$set_color_map((long)0,
  338.                     (short)MAXCOLORS,
  339.                     old_color_value,
  340.                     status);
  341.         gpr_$release_display(status);
  342.     }
  343.     gpr_$terminate(delete_display,status); /*Terminate gpr.*/
  344. }
  345.  
  346. /*
  347.  * APOLLO_color
  348.  *
  349.  *    change the drawing color.
  350.  */
  351. int APOLLO_color(int ind)
  352. {
  353.     if (disp.n_planes <= 1) {
  354.         if (ind > 0)
  355.             current_color = 1;
  356.  
  357.         if (disp.invert)
  358.             current_color = !current_color;
  359.  
  360.     } else {
  361.         current_color = ind % MAXCOLORS;
  362.     }
  363.  
  364.     gpr_$set_draw_value((int)current_color, status); 
  365.     gpr_$set_text_value((int)current_color, status);
  366.     gpr_$set_fill_value((int)current_color, status);
  367.     /*
  368.      * GPR manual says that this sets text background to
  369.      * 'transparent'
  370.      */
  371.     gpr_$set_text_background_value((int)-1, status);
  372. }
  373.  
  374. /*
  375.  * APOLLO_mapcolor
  376.  *
  377.  *    set a colormap entry.
  378.  */
  379. int APOLLO_mapcolor(
  380.   int in,
  381.   short r,
  382.   short g,
  383.   short b)
  384. {
  385.     if (in < 0 || in > MAXCOLORS)
  386.